Calibration

Several types of calibrations are supported. The simplest calibration assumes that frequency response is "flat". In other words, if you send a 1V RMS tone to the speaker, it will always produce the same output level regardless of frequency. You can also have calibrations that compensate for variations in speaker output as a function of frequency.

For simplicity, let's assume our speaker's response is flat. First, import the calibration class that supports flat calibrations.

Now, let's assume that when we play a 1V RMS tone through the speaker, it produces an output of 114 dB SPL. Sensitivity of acoustic systems are almost always reported in volts per Pascal. 114 dB SPL is 10 Pascals. This means that the sensitivity of the speaker is 0.1 Volt per Pascal.

By design, the sensitivity must be converted to dB(volts/Pascal) when initializing the calibration. This translates to a value of -20 dB(V/Pa) for a sensitivity of 0.1 V/Pa.

One Pascal is 94 dB. Let's see if this works. The method, Calibration.get_sf gives us the RMS amplitude of the waveform needed to generate a tone at the given frequency and level. We would expect the RMS value to be 0.1.

Remember that 6 dB translates to half on a linear scale. Let's confirm this works.

Generating stimuli

Introduction

Now that we've defined our calibration, we can generate a stimulus waveform. Let's start with the simplest possible type of stimulus, a tone. First, we import the ToneFactory class and create an instance.

Note that we had to provide the sampling frequency the tone must be generated at along with other stimulus parameters.

The instance supports several methods that are used by psiexperiment to properly handle the tone. For example, we need to know how long the stimulus is.

This means the tone can run continuously for the full duration of the experiment. You may use a continuous waveform (e.g., bandlimited noise) for generating a background masker.

Let's get the first 5000 samples of the tone.

Let's get the next 1000 samples.

As you can see, a factory supports incremential generation of waveforms. This enables us to generate infinitely long waveforms (such as maskers) that never repeat.

More complex stimuli

Tones are boring. Let's look at a more interesting type of stimulus. Sinusoidally-amplitude modulated noise with a cosine-squared onset/offset ramp.

Like tone factories, the bandlimited noise factory can run forever if you want it to.

Now, let's embed the noise in a sinusoidally amplitude-modulated (SAM) envelope. Note that when we create this factory, we provide the noise we created as an argument to the parameter input_waveform.

Now, embed the SAM noise inside a cosine-squared envelope.

By definition, a cosine-squared envelope has a finite duration. Let's plot the first two seconds.

Now, the next two seconds.

What happens if we keep going? Remember the duration of the stimulus is only 4 seconds.

That's because the stimulus is over. We can check that this is the case.

What if we want to start over at the beginning? Reset it.

Even more complex stimuli

Not all stimuli have to be composed of individual building blocks (e.g., envelopes, modulators and carriers). We can also define discrete waveform factories that can be used as-is. For example, chirps.

Creating your own

You would subclass psi.token.primitives.Waveform and implement the following methods:

• __init__: Where you perform potentially expensive computations (such as the filter coefficients for bandlimited noise)
• reset: Where you reset any settings that are releavant to incremential generation of the waveform (e.g., the initial state of the filter and the random number generator for bandlimited noise).
• next: Where you actually generate the waveform.
• get_duration: The duration of the waveform. Return np.inf if continuous.

Want to look at an example of a relatively complex waveform? See bandlimited noise or chirps.

Defining user-configurable stimuli parameters

We use Enaml, which is a superset of Python's syntax to create a plugin-oriented system. When running psiexperiment in workbench mode, you have a number of plugins that you can contribute to. One plugin is psi.context.items. All items contributed to this plugin will appear in the GUI.

You can contribute new context items to this plugin by defining a manifest. A manifest looks like this.

Note a few things:

• The manifest is linked to the corresponding factory
• The manifest defines a list of parameters that can be configured by the user.

The details of how a particular waveform's parameters actually appear in the context registry are a bit complex (and can likely be simplified once I have the time). So, let's illustrate a simpler example of how the context plugin works.